ObjectExtension[Transform].cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2013-2016
// </copyright>
// <summary>   A tested, generic, portable, runtime-extensible type converter library   </summary
// <language>  C# > 6.0                                                                 </language>
// <version>   3.1.0.2                                                                  </version>
// <author>    Lorenz Lo Sauer; people credited in the sources                          </author>
// <project>   https://github.com/lsauer/dotnet-portable-type-cast                      </project>
namespace Core.TypeCast
{
    using System;
    using System.Reflection;
    using System.Linq;
    using System.Runtime.CompilerServices;

    using Core.TypeCast.Base;
    using Core.Extensions;

    public static partial class ObjectExtension
    {

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this TOut self, Enum functionAlias)
        {
            return Transform<TOut>(self: self, model: null, functionAlias: functionAlias.ToString());
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this TOut self, object model, Enum functionAlias, bool strictTypeCheck = true, bool withContext = false)
        {
            return Transform<TOut>(self: self, model: model, functionAlias: functionAlias.ToString(), withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this object self, Enum functionAlias)
        {
            return (TOut)Transform(self: self, model: null, typeBase: null, typeTo: typeof(TOut), functionAlias: functionAlias.ToString(), throwException: false);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this object self, object model, Enum functionAlias, bool withContext = false)
        {
            return (TOut)Transform(self: self, model: null, typeBase: null, typeTo: typeof(TOut), functionAlias: functionAlias.ToString(), throwException: false, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this TOut self, object model, string functionAlias = null, bool withContext = false)
        {
            return (TOut)Transform(self: self, model: model, typeBase: null, typeTo: typeof(TOut), functionAlias: functionAlias, throwException: false, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TBase, TOut>(this object self, object model = null, string functionAlias = null, bool strictTypeCheck = false, bool withContext = false)
        {
            CheckTransformTypes<TOut>(self, strictTypeCheck);
            return (TOut)Transform<TBase, object, TOut>(self: self, model: model, functionAlias: functionAlias, strictTypeCheck: strictTypeCheck, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TBase, TIn, TOut>(this object self, object model = null, string functionAlias = null, bool strictTypeCheck = false, bool withContext = false)
        {
            CheckTransformTypes<TOut>(self, strictTypeCheck);
            Converter converter = null;
            return (TOut)Transform<TIn>(self: (TIn)self, converter: out converter, model: model, typeBase: typeof(TBase), typeTo: typeof(TOut), functionAlias: functionAlias, throwException: false, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TOut>(this TOut self, Type typeBase, object model = null, string functionAlias = null, bool withContext = false)
        {
            return (TOut)Transform(self: self, model: model, typeBase: null, typeTo: typeof(TOut), functionAlias: functionAlias, throwException: false, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static object Transform<TBase>(this object self, object model = null, Type typeBase = null, Type typeTo = null, string functionAlias = null, bool throwException = true, bool withContext = false)
        {
            return Transform(self: self, model: model, typeBase: typeof(TBase), typeTo: typeTo, functionAlias: functionAlias, throwException: throwException, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static object Transform(this object self, object model = null, Type typeBase = null, Type typeTo = null, string functionAlias = null, bool throwException = true, bool withContext = false)
        {
            Converter converter = null;
            return Transform(self: self, converter: out converter, model: model, typeBase: typeBase, typeTo: typeTo, functionAlias: functionAlias, throwException: throwException, withContext: withContext);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static object Transform<TIn>(this TIn self, out Converter converter, object model = null, Type typeBase = null, Type typeTo = null, string functionAlias = null, bool throwException = true, bool withContext = false)
        {
            object result = null;
            // transform should be used for similar or same types as the input type, as such if no typeTo is supplied let's use the delegate's return-type
            typeTo = typeTo ?? typeBase?.GetTypeInfo().GetReturnParameterType();
            if(typeof(TIn) != objectType && typeBase?.GetTypeInfo().IsInvokableWithParameters(typeTo, self.GetType(), model?.GetType()) == false)
            {
                throw new ConverterException(ConverterCause.DelegateArgumentWrongType);
            }
            GetConverterOrDefault<TIn, object>(self, out converter, out result, typeArgument: model?.GetType(), typeTo: functionAlias != null ? null : typeTo, typeBase: typeBase,
                throwException: throwException, unboxObjectType: typeof(TIn) != objectType, attributeName: functionAlias);

            InvokeConvert(self, out result, model, throwException: throwException, converter: converter, contextInstance: (withContext ? new ConvertContext(model) : null));
            return result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut Transform<TIn, TOut>(this TIn self, Func<TIn, TOut> converterAction, Enum addWithAttributeName, bool throwException = true)
        {
            return Transform<TIn, TOut>(self: self, converterAction: converterAction, addWithAttributeName: addWithAttributeName.ToString(), throwException: throwException);
        }

        public static TOut Transform<TIn, TOut>(this TIn self, Func<TIn, TOut> converterAction, string addWithAttributeName = null, bool throwException = true)
        {
            TOut result = default(TOut);
            Converter converter = null;
            converter = ConverterCollection.CurrentInstance.Factory.Create<TIn, TOut>(converterAction);
            var baseType = converterAction?.Target?.GetType().DeclaringType;

            if(String.IsNullOrWhiteSpace(addWithAttributeName) == false)
            {
                // set an alias for later filtering of transform functions
                converter.Attribute = new ConverterAttribute(loadOnDemand: false, name: addWithAttributeName, nameSpace: baseType.Namespace);
                ConverterCollection.CurrentInstance.Add(converter, allowDisambiguates: true);
            }

            InvokeConvert(self: self, result: out result, defaultValue: default(TOut), throwException: throwException, converter: converter);

            return result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool TryTransform(this object self, out object result, object model = null, Type typeBase = null, Type typeTo = null, string functionAlias = null, bool throwException = false, bool withContext = false)
        {
            Converter converter = null;
            result = Transform(self: self, converter: out converter, model: model, typeBase: typeBase, typeTo: typeTo, functionAlias: functionAlias, throwException: throwException, withContext: withContext);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool TryTransform<TIn, TOut>(this TIn self, out TOut result, object model = null, Type typeBase = null, string functionAlias = null, bool throwException = false, bool withContext = false)
        {
            Converter converter = null;
            result = (TOut)Transform(self: self, converter: out converter, model: model, typeBase: typeBase, typeTo: typeof(TOut), functionAlias: functionAlias, throwException: throwException, withContext: withContext);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool TryTransform<TBase, TOut>(this object self, out TOut result, object model = null, string functionAlias = null, bool throwException = false, bool withContext = false)
        {
            Converter converter = null;
            result = (TOut)Transform(self: self, converter: out converter, model: model, typeBase: typeof(TBase), typeTo: typeof(TOut), functionAlias: functionAlias, throwException: throwException, withContext: withContext);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool TryTransform<TBase, TIn, TOut>(this TIn self, out TOut result, object model = null, string functionAlias = null, bool throwException = false, bool withContext = false)
        {
            Converter converter = null;
            result = (TOut)Transform<TIn>(self: self, converter: out converter, model: model, typeBase: typeof(TBase), typeTo: typeof(TOut), functionAlias: functionAlias, throwException: throwException, withContext: withContext);
            return converter != null;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static void CheckTransformTypes<TOut>(object self, bool strictTypeCheck)
        {
            var sameOrSimilar = self.GetType().GetTypeInfo().IsSameOrSimilar<TOut>();
            if((strictTypeCheck == true && sameOrSimilar == TypeMatch.None))
            {
                throw new ConverterException(ConverterCause.TransformRequiresEqualInOutTypes);
            }
        }
    }
}